home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / metkit / k4viewx.h < prev    next >
C/C++ Source or Header  |  1997-06-07  |  8KB  |  245 lines
  1. //    Copyright (C) 1996, 1997 Meta Four Software.  All rights reserved.
  2. //
  3. //    Auxiliary view declarations
  4. //
  5. //! rev="$Id: k4viewx.h,v 1.18 1997/06/05 08:31:58 jcw Rel $"
  6.  
  7. #ifndef __K4VIEW_H__
  8.     #error This file is included by "k4view.h", it cannot be used standalone
  9. #endif
  10.  
  11. /////////////////////////////////////////////////////////////////////////////
  12. // Declarations in this file
  13.  
  14.     class c4_Sequence;                    // a collection of rows
  15.  
  16.     class c4_Reference;                 // refers to the actual data values
  17.         class c4_IntRef;
  18.         class c4_FloatRef;
  19.         class c4_DoubleRef;
  20.         class c4_StringRef;
  21.         class c4_BytesRef;
  22.         class c4_ViewRef;
  23.  
  24.     class c4_Dependencies;                // not defined here
  25.     class c4_Handler;                    // not defined here
  26.     class c4_Notifier;                    // not defined here
  27.  
  28. /////////////////////////////////////////////////////////////////////////////
  29. //: A sequence is an abstract base class for views on ranges of records.
  30. //
  31. //    Sequences represent arrays of rows (or indexed collections / tables).
  32. //    Insertion and removal of entries is allowed, but could take linear time.
  33. //    A reference count is maintained to decide when the object should go away.
  34.  
  35. class c4_Sequence
  36. {
  37.     int _refCount;
  38.         /* Reference count. */
  39.     c4_Dependencies* _dependencies;
  40.         /* Pointer to depency list, or null if nothing depends on this. */
  41.     int _lastPropIndex;
  42.         /* Optimization: cached property index. */
  43. protected:
  44.     int _lastPropId; // see c4_HandlerSeq::Reset()
  45.         /* Optimization: cached property id. */
  46.  
  47. public: 
  48. /* General */
  49.     c4_Sequence ();
  50.         //: Abstract constructor.
  51.     
  52.     virtual int Compare(int, c4_Cursor) const;
  53.         //: Compares the specified row with another one.
  54.     void SetAt(int, c4_Cursor);
  55.         //: Replaces the contents of a specified row.
  56.     virtual int RemapIndex(int, const c4_Sequence*) const;
  57.         //: Remaps the index to an underlying view.
  58.     
  59.     c4_String Describe() const;
  60.         //: Returns a descriptions of the current data structure.
  61.  
  62. /* Reference counting */
  63.     void IncRef();
  64.         //: Increments the reference count of this sequence.
  65.     void DecRef();
  66.         //: Decrements the reference count, delete objects when last.
  67.     int NumRefs() const;
  68.         //: Returns the current number of references to this sequence.
  69.  
  70. /* Adding / removing rows */
  71.     virtual int Size() const = 0;
  72.         //: Returns the current number of rows.
  73.     void Resize(int, int =-1);
  74.         //: Changes number of rows, either by inserting or removing them.
  75.     
  76.     virtual void InsertAt(int, c4_Cursor, int =1);
  77.         //: Inserts one or more rows into this sequence.
  78.     virtual void RemoveAt(int, int =1);
  79.         //: Removes one or more rows from this sequence.
  80.     virtual void Move(int, int);
  81.         //: Move a row to another position.
  82.  
  83. /* Properties */
  84.     int NthProperty(int) const;
  85.         //: Returns the id of the N-th property.
  86.     int PropIndex(int, bool =false);
  87.         //: Finds the index of a property, or creates a new entry.
  88.     
  89.     virtual int NumHandlers() const = 0;
  90.         //: Returns the number of data handlers in this sequence.
  91.     virtual c4_Handler& NthHandler(int) const = 0;
  92.         //: Returns a reference to the N-th handler in this sequence.
  93.     virtual const c4_Sequence* HandlerContext(int) const = 0;
  94.         //: Returns the context of the N-th handler in this sequence.
  95.     virtual int AddHandler(c4_Property&, c4_Handler*) = 0;
  96.         //: Adds the specified data handler to this sequence.
  97.  
  98. /* Element access */
  99.     virtual bool Get(int, int, c4_Bytes&);
  100.         //: Retrieves one data item from this sequence.
  101.     virtual void Set(int, int, const c4_Bytes&);
  102.         //: Stores a data item into this sequence.
  103.     
  104. /* Dependency notification */
  105.     void Attach(c4_Sequence* child_);
  106.         //: Registers a sequence to receive change notifications.
  107.     void Detach(c4_Sequence* child_);
  108.         //: Unregisters a sequence which received change notifications.
  109.     c4_Dependencies* GetDependencies() const;
  110.         //: Returns a pointer to the dependencies, or null.
  111.  
  112.     virtual c4_Notifier* PreChange(c4_Notifier& nf_);
  113.         //: Called just before a change is made to the sequence.
  114.     virtual void PostChange(c4_Notifier& nf_);
  115.         //: Called after changes have been made to the sequence.
  116.     
  117. protected:
  118.     virtual ~c4_Sequence ();
  119.  
  120. public: //! for c4_Table::Sequence setup
  121.     virtual void SetSize(int size_) = 0;
  122.  
  123. private:
  124.     c4_Sequence (const c4_Sequence&);    // not implemented
  125.     void operator= (const c4_Sequence&); // not implemented
  126. };
  127.  
  128. /////////////////////////////////////////////////////////////////////////////
  129. //: A reference is used to get or set typed data, using derived classes.
  130. //
  131. //    Objects of this class are only intended to be used as a temporary handle
  132. //    while getting and setting properties in a row.    They are normally only
  133. //    constructed as result of function overload operators: "property (row)".
  134. //
  135. //    See: c4_IntRef, c4_FloatRef, c4_DoubleRef, 
  136. //    c4_StringRef, c4_BytesRef, c4_ViewRef
  137.  
  138. class c4_Reference
  139. {
  140.     c4_Cursor _cursor;
  141.         /* The cursor which points to the data. */
  142.     int _propId;
  143.         /* The property id associated to this reference. */
  144.  
  145. public:
  146.     c4_Reference (c4_RowRef, int);
  147.         //: Constructor.
  148.  
  149.     c4_Reference& operator= (const c4_Reference&);
  150.         //: Assignment of one data item.
  151.  
  152.     bool GetData(c4_Bytes&) const;
  153.         //: Retrieves the value of the referenced data item.
  154.     void SetData(const c4_Bytes&) const;
  155.         //: Stores a value into the referenced data item.
  156.     
  157.     friend bool operator== (const c4_Reference&, const c4_Reference&);
  158.         //: Returns true if the contents of both references is equal.
  159.     friend bool operator!= (const c4_Reference&, const c4_Reference&);
  160.         //: Returns true if the contents of both references is not equal.
  161.  
  162. private:
  163.     void operator& () const;            // not implemented
  164. };
  165.  
  166. /////////////////////////////////////////////////////////////////////////////
  167.  
  168.     //: Used to get or set integer values.
  169. class c4_IntRef : public c4_Reference
  170. {
  171. public:
  172.     c4_IntRef (const c4_Reference&);
  173.         //: Constructor.
  174.     operator t4_i32 () const;
  175.         //: Gets the value as long integer.
  176.     c4_IntRef& operator= (t4_i32);
  177.         //: Sets the value to the specified long integer.
  178. };
  179.  
  180. #if !q4_TINY
  181.  
  182.     //: Used to get or set floating point values.
  183. class c4_FloatRef : public c4_Reference
  184. {
  185. public:
  186.     c4_FloatRef (const c4_Reference&);
  187.         //: Constructor.
  188.     operator double () const;
  189.         //: Gets the value as floating point.
  190.     c4_FloatRef& operator= (double);
  191.         //: Sets the value to the specified floating point.
  192. };
  193.  
  194.     //: Used to get or set double precision values.
  195. class c4_DoubleRef : public c4_Reference
  196. {
  197. public:
  198.     c4_DoubleRef (const c4_Reference&);
  199.         //: Constructor.
  200.     operator double () const;
  201.         //: Gets the value as floating point.
  202.     c4_DoubleRef& operator= (double);
  203.         //: Sets the value to the specified floating point.
  204. };
  205.  
  206. #endif // !q4_TINY
  207.  
  208.     //: Used to get or set string values.
  209. class c4_StringRef : public c4_Reference
  210. {
  211. public:
  212.     c4_StringRef (const c4_Reference&);
  213.         //: Constructor.
  214.     operator c4_String () const;
  215.         //: Gets the value as string.
  216.     c4_StringRef& operator= (const char*);
  217.         //: Sets the value to the specified string.
  218. };
  219.  
  220.     //: Used to get or set binary object values.
  221. class c4_BytesRef : public c4_Reference
  222. {
  223. public:
  224.     c4_BytesRef (const c4_Reference&);
  225.         //: Constructor.
  226.     operator c4_Bytes () const;
  227.         //: Gets the value as string.
  228.     c4_BytesRef& operator= (const c4_Bytes&);
  229.         //: Sets the value to the specified string.
  230. };
  231.  
  232.     //: Used to get or set view values.
  233. class c4_ViewRef : public c4_Reference
  234. {
  235. public:
  236.     c4_ViewRef (const c4_Reference&);
  237.         //: Constructor.
  238.     operator c4_View () const;
  239.         //: Gets the value as view.
  240.     c4_ViewRef& operator= (const c4_View&);
  241.         //: Sets the value to the specified view.
  242. };
  243.  
  244. /////////////////////////////////////////////////////////////////////////////
  245.